home *** CD-ROM | disk | FTP | other *** search
/ Aminet 32 / Aminet 32 (1999)(Schatztruhe)[!][Aug 1999].iso / Aminet / disk / misc / ADFlib.lha / Lib / adf_dump.c < prev    next >
C/C++ Source or Header  |  1999-05-01  |  5KB  |  228 lines
  1. /*
  2.  * ADF Library
  3.  *
  4.  * adf_dump.c
  5.  *
  6.  * Amiga Dump File specific routines
  7.  */
  8.  
  9. #include<stdio.h>
  10. #include<stdlib.h>
  11.  
  12. #include"adf_defs.h"
  13. #include"adf_str.h"
  14. #include"adf_disk.h"
  15. #include"adf_nativ.h"
  16. #include"adf_err.h"
  17.  
  18. extern struct Env adfEnv;
  19.  
  20. /*
  21.  * adfInitDumpDevice
  22.  *
  23.  */
  24. RETCODE adfInitDumpDevice(struct Device* dev, char* name)
  25. {
  26.     struct nativeDevice* nDev;
  27.     long size;
  28.  
  29.     nDev = (struct nativeDevice*)dev->nativeDev;
  30.  
  31.     nDev = (struct nativeDevice*)malloc(sizeof(struct nativeDevice));
  32.     if (!nDev) {
  33.         (*adfEnv.eFct)("adfInitDumpDevice : malloc");
  34.         return RC_MALLOC;
  35.     }
  36.     dev->nativeDev = nDev;
  37.  
  38.     nDev->fd = fopen(name,"rb+");
  39.     if (!nDev->fd) {
  40.         free(nDev);
  41.         (*adfEnv.eFct)("myInitDevice : fopen");
  42.         return RC_ERROR;
  43.     }
  44.  
  45.     /* determines size */
  46.     fseek(nDev->fd, 0, SEEK_END);
  47.     size = ftell(nDev->fd);
  48.     fseek(nDev->fd, 0, SEEK_SET);
  49.  
  50.     dev->size = size;
  51.     
  52.     return RC_OK;
  53. }
  54.  
  55.  
  56. /*
  57.  * adfReadDumpSector
  58.  *
  59.  */
  60. RETCODE adfReadDumpSector(struct Device *dev, long n, int size, unsigned char* buf)
  61. {
  62.     struct nativeDevice* nDev;
  63.     int r;
  64. //puts("adfReadDumpSector");
  65.     nDev = (struct nativeDevice*)dev->nativeDev;
  66.     r = fseek(nDev->fd, 512*n, SEEK_SET);
  67. //printf("nnn=%ld size=%d\n",n,size);
  68.     if (r==-1)
  69.         return RC_ERROR;
  70. //puts("123");
  71.     if ((r=fread(buf, 1, size, nDev->fd))!=size) {
  72. //printf("rr=%d\n",r);
  73.         return RC_ERROR;
  74. }
  75. //puts("1234");
  76.  
  77.     return RC_OK;
  78. }
  79.  
  80.  
  81. /*
  82.  * adfWriteDumpSector
  83.  *
  84.  */
  85. RETCODE adfWriteDumpSector(struct Device *dev, long n, int size, unsigned char* buf)
  86. {
  87.     struct nativeDevice* nDev;
  88.     int r;
  89.  
  90.     nDev = (struct nativeDevice*)dev->nativeDev;
  91.  
  92.     r=fseek(nDev->fd, 512*n, SEEK_SET);
  93.     if (r==-1)
  94.         return RC_ERROR;
  95.  
  96.     if ( fwrite(buf, 1, size, nDev->fd)!=(unsigned int)(size) )
  97.         return RC_ERROR;
  98. //puts("adfWriteDumpSector");
  99.     return RC_OK;
  100. }
  101.  
  102.  
  103. /*
  104.  * adfReleaseDumpDevice
  105.  *
  106.  */
  107. RETCODE adfReleaseDumpDevice(struct Device *dev)
  108. {
  109.     struct nativeDevice* nDev;
  110.  
  111.     if (!dev->nativeDev)
  112.         return RC_ERROR;
  113.  
  114.     nDev = (struct nativeDevice*)dev->nativeDev;
  115.     fclose(nDev->fd);
  116.  
  117.     free(nDev);
  118.  
  119.     return RC_OK;
  120. }
  121.  
  122.  
  123. /*
  124.  * adfCreateHdFile
  125.  *
  126.  */
  127. RETCODE adfCreateHdFile(struct Device* dev, char* volName, int volType)
  128. {
  129.     
  130.     if (dev==NULL) {
  131.         (*adfEnv.eFct)("adfCreateHdFile : dev==NULL");
  132.         return RC_ERROR;
  133.     }
  134.     dev->volList =(struct Volume**) malloc(sizeof(struct Volume*));
  135.     if (!dev->volList) { 
  136.                 (*adfEnv.eFct)("adfCreateHdFile : unknown device type");
  137.         return RC_ERROR;
  138.     }
  139.  
  140.     dev->volList[0] = adfCreateVol( dev, 0L, (long)dev->cylinders, volName, volType );
  141.     if (dev->volList[0]==NULL) {
  142.         free(dev->volList);
  143.         return RC_ERROR;
  144.     }
  145.  
  146.     dev->nVol = 1;
  147.     dev->devType = DEVTYPE_HARDFILE;
  148.  
  149.     return RC_OK;
  150. }
  151.  
  152.  
  153. /*
  154.  * adfCreateDumpDevice
  155.  *
  156.  * returns NULL if failed
  157.  */ 
  158.     struct Device*
  159. adfCreateDumpDevice(char* filename, long cylinders, long heads, long sectors)
  160. {
  161.     struct Device* dev;
  162.     unsigned char buf[LOGICAL_BLOCK_SIZE];
  163.     struct nativeDevice* nDev;
  164. //    long i;
  165.     int r;
  166.     
  167.     dev=(struct Device*)malloc(sizeof(struct Device));
  168.     if (!dev) { 
  169.         (*adfEnv.eFct)("adfCreateDumpDevice : malloc dev");
  170.         return NULL;
  171.     }
  172.     nDev = (struct nativeDevice*)malloc(sizeof(struct nativeDevice));
  173.     if (!nDev) {
  174.         free(dev); 
  175.         (*adfEnv.eFct)("adfCreateDumpDevice : malloc nDev");
  176.         return NULL;
  177.     }
  178.     dev->nativeDev = nDev;
  179.  
  180.     nDev->fd = (FILE*)fopen(filename,"wb");
  181.     if (!nDev->fd) {
  182.         free(nDev); free(dev);
  183.         (*adfEnv.eFct)("adfCreateDumpDevice : fopen");
  184.         return NULL;
  185.     }
  186.  
  187. /*    for(i=0; i<cylinders*heads*sectors; i++)
  188.         fwrite(buf, sizeof(unsigned char), 512 , nDev->fd);
  189. */
  190.     r=fseek(nDev->fd, ((cylinders*heads*sectors)-1)*LOGICAL_BLOCK_SIZE, SEEK_SET);
  191.     if (r==-1) {
  192.         fclose(nDev->fd); free(nDev); free(dev);
  193.         (*adfEnv.eFct)("adfCreateDumpDevice : fseek");
  194.         return NULL;
  195.     }
  196.  
  197.     fwrite(buf, LOGICAL_BLOCK_SIZE, 1, nDev->fd);
  198.  
  199.     fclose(nDev->fd);
  200.  
  201.     nDev->fd=(FILE*)fopen(filename,"rb+");
  202.     if (!nDev->fd) {
  203.         free(nDev); free(dev);
  204.         (*adfEnv.eFct)("adfCreateDumpDevice : fopen");
  205.         return NULL;
  206.     }
  207.     dev->cylinders = cylinders;
  208.     dev->heads = heads;
  209.     dev->sectors = sectors;
  210.     dev->size = cylinders*heads*sectors* LOGICAL_BLOCK_SIZE;    
  211.  
  212.     if (dev->size==80*11*2*LOGICAL_BLOCK_SIZE)
  213.         dev->devType = DEVTYPE_FLOPDD;
  214.     else if (dev->size==80*22*2*LOGICAL_BLOCK_SIZE)
  215.         dev->devType = DEVTYPE_FLOPHD;
  216.     else     
  217.         dev->devType = DEVTYPE_HARDDISK;
  218.         
  219.     dev->nVol = 0;
  220.     dev->isNativeDev = FALSE;
  221.     dev->readOnly = FALSE;
  222.  
  223.     return(dev);
  224. }
  225.  
  226. /*##################################################################################*/
  227.  
  228.